home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 1 / LIGHT-ROM 1 (Amiga Library Services)(1994).iso / ffdisks / d882.lha / GALer / GALer_english / Source / GALerSrcE.lha / Pruefer.c < prev    next >
C/C++ Source or Header  |  1992-12-26  |  11KB  |  491 lines
  1. /****************************************************************/
  2. /*                                */
  3. /* Pruefer - legt Prüfmuster an die Eingänge des GALs und    */
  4. /* gibt Auskunft über den Zustand der Ausänge            */
  5. /*                                */
  6. /* compilieren: cc Pruefer.c                    */
  7. /****************************************************************/
  8.  
  9.  
  10. #include <intuition/intuition.h>
  11. #include <stdio.h>
  12. #include <functions.h>
  13.  
  14. #include "GALer.h"
  15.  
  16.  
  17. extern    int    pruef_mode;
  18. extern    int    GALType;
  19. extern    int    gal_type;
  20. extern    int    outIC3;
  21. extern    int    outIC4;
  22. extern    int    outIC5;
  23. extern    int    asmreadyflag;
  24. extern    int    num_of_pins;
  25.  
  26. extern    UBYTE    PinNames[24][10];
  27.  
  28. extern  struct    Window        *window;
  29. extern    struct    RastPort    *rp;
  30. extern    struct    Border        Border1;
  31. extern    struct    Border        Border2;
  32.  
  33. extern    struct    Menu        Menu1;
  34. extern    struct    Menu        MenuP;
  35.  
  36. extern    struct    Gadget        Gadget1;
  37. extern    struct    Gadget        Gadget4;
  38. extern    struct    Gadget        Gadget20;
  39. extern    struct    Gadget        Gadget21;
  40. extern    struct    Gadget        Gadget23;
  41. extern    struct    Gadget        Gadget25;
  42. extern    struct    Gadget        Gadget27;
  43. extern    struct    Gadget        Gadget29;
  44. extern    struct    Gadget        Gadget31;
  45. extern    struct    Gadget        Gadget33;
  46. extern    struct    Gadget        Gadget35;
  47.  
  48.  
  49.  
  50. struct    in_con      { int IC16V8;
  51.             int Pin16V8;
  52.               int IC20V8;
  53.             int Pin20V8;
  54.             int EA;
  55.             int Pegel; };
  56.  
  57. struct    out_con      { int IC16V8;
  58.             int Bit16V8;
  59.             int IC20V8;
  60.             int Bit20V8;
  61.             struct Gadget *Gad; };
  62.  
  63.  
  64. /*Aufbau der nachfolgenden Struktur: 
  65.  für GAL16V8:
  66.  1. Eintrag: IC, das für den Zugriff auf den Pin mit der GadID zuständig ist
  67.  2. Eintrag: Bit des ICs
  68.  für GAL20V8:
  69.  3. Eintrag: IC, das für den Zugriff auf den Pin mit der GadId zuständig ist
  70.  4. Eintrag: Bit des ICs
  71.  allgemein:
  72.  5. Eintrag: Pin als Ein- bzw. Ausgang definiert
  73.  6. Eintrag: wenn Pin Eingang ist, dann gibt dieser Eintrag den Pegel an
  74. */
  75. struct in_con  in_bit[22] = { {IC4,0x04,IC4,0x04,EINGANG,LOW},
  76.                   {IC4,0x08,IC4,0x08,EINGANG,LOW},
  77.                   {IC4,0x10,IC4,0x10,EINGANG,LOW},
  78.                   {IC4,0x20,IC4,0x20,EINGANG,LOW},
  79.                   {IC4,0x40,IC4,0x40,EINGANG,LOW},
  80.                   {IC4,0x80,IC4,0x80,EINGANG,LOW},
  81.                   {IC5,0x01,IC5,0x01,EINGANG,LOW},
  82.                   {IC5,0x02,IC5,0x02,EINGANG,LOW},
  83.                   {IC5,0x04,IC5,0x04,EINGANG,LOW},
  84.                   {IC5,0x08,IC5,0x08,EINGANG,LOW},
  85.                   {IC4,0x00,IC4,0x01,EINGANG,LOW},
  86.                   {IC3,0x00,IC3,0x80,EINGANG,LOW},
  87.                   {IC4,0x00,IC4,0x02,EINGANG,LOW},
  88.                   {IC5,0x00,IC5,0x10,EINGANG,LOW},
  89.                   {IC5,0x10,IC5,0x20,AUSGANG,LOW},
  90.                   {IC5,0x20,IC3,0x01,AUSGANG,LOW},
  91.                   {IC3,0x01,IC3,0x02,AUSGANG,LOW},
  92.                   {IC3,0x02,IC3,0x04,AUSGANG,LOW},
  93.                   {IC3,0x04,IC3,0x08,AUSGANG,LOW},
  94.                   {IC3,0x08,IC3,0x10,AUSGANG,LOW},
  95.                   {IC3,0x10,IC3,0x20,AUSGANG,LOW},
  96.                   {IC3,0x20,IC3,0x40,AUSGANG,LOW}  };
  97.  
  98.  
  99. /*Aufbau der nachfolgenden Struktur: 
  100.  für GAL16V8:
  101.  1. Eintrag: IC, das den Pin mit der GadID ausliest
  102.  2. Eintrag: Bit des ICs
  103.  für GAL20V8:
  104.  1. Eintrag: IC, das den Pin mit der GadID ausliest
  105.  4. Eintrag: Bit des ICs
  106. */
  107. struct out_con out_bit[8] = { {IC7,0x01,IC7,0x02,&Gadget35},
  108.                   {IC7,0x02,IC7,0x04,&Gadget33},
  109.                   {IC7,0x04,IC7,0x08,&Gadget31},
  110.                   {IC7,0x08,IC7,0x10,&Gadget29},
  111.                   {IC7,0x10,IC7,0x20,&Gadget27},
  112.                   {IC7,0x20,IC7,0x40,&Gadget25},
  113.                   {IC7,0x40,IC7,0x80,&Gadget23},
  114.                   {IC7,0x80,IC6,0x01,&Gadget21}  };
  115.  
  116.  
  117.  
  118.  
  119. void Pruefer(gad,gadID)
  120. struct    Gadget    *gad;
  121. USHORT    gadID;
  122. {
  123. UBYTE    c;
  124.  
  125.  c=(UBYTE)*gad->GadgetText->IText;
  126.                         /*Eingabe-Gadgets*/
  127.  if ((gadID>=1)&&(gadID<=22)) {
  128.    if (gad->GadgetRender!=(APTR)&Border2) {
  129.      if (c=='L') {
  130.        c='H';
  131.        in_bit[gadID-1].Pegel=HIGH;
  132.        SetPegel(gadID,HIGH);
  133.       }
  134.      else {
  135.        c='L';
  136.        in_bit[gadID-1].Pegel=LOW;
  137.        SetPegel(gadID,LOW);
  138.       }
  139.     }
  140.   }
  141.                         /*Ein- u. Ausgabe-Gadgets (A/E)*/
  142.  if ((gadID>=30)&&(gadID<=37)) {
  143.    if (c=='O') {
  144.      c='I';
  145.      gad->NextGadget->GadgetRender=(APTR)&Border1;
  146.      *gad->NextGadget->GadgetText->IText='L';
  147.      SetPegel(gadID-16,LOW);
  148.      in_bit[gadID-16].EA=EINGANG;
  149.     }
  150.    else {
  151.      c='O';
  152.      gad->NextGadget->GadgetRender=(APTR)&Border2;
  153.      in_bit[gadID-16].EA=AUSGANG;
  154.      SetPegel(gadID-16,LOW);
  155.      CheckOutput();
  156.     }
  157.   }
  158.  
  159.  CheckOutput();
  160.  
  161.  *gad->GadgetText->IText=c;
  162.  RefreshGList(gad->NextGadget,window,NULL,1L);
  163.  RefreshGList(gad,window,NULL,1L);
  164.  
  165. }
  166.  
  167.  
  168.  
  169.  
  170. /*setze den Pin mit der "gadID" auf "Pegel" (=HIGH oder LOW)*/
  171. void SetPegel(gadID,Pegel)
  172. USHORT    gadID;
  173. int    Pegel;
  174. {
  175. int    bits,ICnum,outIC;
  176.  
  177.  if (GALType==GAL16V8) {
  178.    ICnum=in_bit[gadID-1].IC16V8;
  179.    bits =in_bit[gadID-1].Pin16V8;
  180.   }
  181.  else {
  182.    ICnum=in_bit[gadID-1].IC20V8;
  183.    bits =in_bit[gadID-1].Pin20V8;
  184.   }
  185.  
  186.  if (ICnum==IC3) outIC=outIC3;
  187.  if (ICnum==IC4) outIC=outIC4;
  188.  if (ICnum==IC5) outIC=outIC5;
  189.  
  190.  bits^=0xFF;                /*invertieren*/
  191.  outIC&=bits;                /*Bit für Pin löschen*/
  192.  if (Pegel==HIGH) {            /*falls HIGH-Pegel, Bit wieder setzen*/
  193.    bits^=0xFF;
  194.    outIC|=bits;
  195.   }
  196.  
  197.  WriteByte(outIC,ICnum);        /*Pin auf Pegel setzen*/
  198. }
  199.  
  200.  
  201.  
  202. /*Ausgänge auf HIGH, LOW, hochohmig (Z) prüfen
  203.   Aufruf: Ausgänge müssen über ihre Widerstände auf LOW geschalten sein
  204. */
  205. void CheckOutput()
  206. {
  207. struct    Gadget    *gad;
  208.  
  209. int    n,in_bits,out_bits,pin_pegel,
  210.     inICnum,outICnum,outIC,byte;
  211.  
  212.  
  213.  for(n=14; n<=21; n++) {        /*mögliche Ausgänge:gadID15-22*/ 
  214.    if (in_bit[n].EA==AUSGANG) {
  215.      if (GALType==GAL16V8) {
  216.        outICnum=in_bit[n].IC16V8;
  217.        out_bits=in_bit[n].Pin16V8;
  218.        inICnum =out_bit[n-14].IC16V8;
  219.        in_bits =out_bit[n-14].Bit16V8;
  220.       }
  221.      else {
  222.        outICnum=in_bit[n].IC20V8;
  223.        out_bits=in_bit[n].Pin20V8;
  224.        inICnum =out_bit[n-14].IC20V8;
  225.        in_bits =out_bit[n-14].Bit20V8;
  226.       }
  227.      if (outICnum==IC3) outIC=outIC3;
  228.      if (outICnum==IC4) outIC=outIC4;
  229.      if (outICnum==IC5) outIC=outIC5;
  230.  
  231.      byte=ReadByte(inICnum);        /*Pegel der Ausgänge holen*/
  232.      if (byte&in_bits) pin_pegel=HIGH;    /*Pegel des Pins "berechnen"*/
  233.      else  pin_pegel=LOW;
  234.  
  235.      outIC|=out_bits;            /*Ausgang über Widerstand auf HIGH*/
  236.      WriteByte(outIC,outICnum);
  237.  
  238.      byte=ReadByte(inICnum);        /*Pegel der Ausgänge holen*/
  239.  
  240.      gad=out_bit[n-14].Gad;
  241.      if (pin_pegel!=(1&&(byte&in_bits))) {    /*Ausgang widerspricht nicht->Z*/
  242.        *gad->GadgetText->IText='Z';
  243.        RefreshGList(gad,window,NULL,1L);
  244.       }
  245.      else
  246.        if (pin_pegel==LOW) {
  247.          *gad->GadgetText->IText='L';
  248.          RefreshGList(gad,window,NULL,1L);
  249.         }
  250.        else {
  251.          *gad->GadgetText->IText='H';
  252.          RefreshGList(gad,window,NULL,1L);
  253.         }
  254.  
  255.      outIC&=(out_bits^0xFF);        /*Ausgang wieder auf "LOW schalten"*/
  256.      WriteByte(outIC,outICnum);
  257.     }
  258.   }
  259. }
  260.  
  261.  
  262.  
  263.  
  264. /*Prüfer an- bzw. ausschalten*/
  265. void TogglePruefer()
  266. {
  267. int    n;
  268. struct    Gadget    *gad;
  269.  
  270.  
  271.  if (pruef_mode) {
  272.    LED(OFF);
  273.    DisableVcc();
  274.  
  275.    pruef_mode=OFF;                /*Prüfer verlassen*/
  276.    gad=&Gadget4;                /*Gadget-Text initialisieren*/
  277.    while(gad!=NULL) {
  278.      if (*gad->GadgetText->IText=='I') {
  279.        *gad->GadgetText->IText='O';
  280.        gad->NextGadget->GadgetRender=(APTR)&Border2;
  281.       }
  282.      if (*gad->GadgetText->IText=='H') *gad->GadgetText->IText='L';
  283.      if (*gad->GadgetText->IText=='Z') *gad->GadgetText->IText='L';
  284.      gad=gad->NextGadget; }
  285.   
  286.    RefreshGList(&Gadget4,window,NULL,-1L);
  287.    for (n=0; n<22; n++) {            /*in_bit initialisieren*/
  288.       in_bit[n].Pegel=LOW;
  289.       if (n>=14) in_bit[n].EA=AUSGANG;
  290.      }
  291.    MyRequest(INFO_REQ,(UBYTE *)"Please remove GAL.");
  292.    ClearMenuStrip(window);
  293.    SetMenuStrip(window,&Menu1);
  294.  }
  295.  else {
  296.    if (MyRequest(GALTYPE_REQ,(UBYTE *)"GAL-Checker")) {
  297.      LED(ON);
  298.      EnableVcc();
  299.      pruef_mode=ON;                /*Prüfer initialisieren*/
  300.      WaitForTimer(100000L);
  301.      CheckOutput();                /*Ausgänge untersuchen*/
  302.      ClearMenuStrip(window);
  303.      SetMenuStrip(window,&MenuP);
  304.     }
  305.   }
  306. }
  307.  
  308.  
  309.  
  310.  
  311. /*GAL zeichnen*/
  312. void DrawGAL(type)
  313. int type;
  314. {
  315. int    pins,n,gadypos;
  316. long    ypos,ic_hight;
  317. char    pinnum[2];                /*Pin-Nummer in ASCII*/
  318. struct    Gadget    *gad;
  319.  
  320.  
  321.  ClearPinNames();
  322.  
  323.  SetAPen(rp,0L);
  324.  RectFill(rp,240L,19L,400L,150L);
  325.  SetAPen(rp,1L);
  326.  
  327.  if (window->FirstGadget==NULL)            /*Gadgetlist in Window*/
  328.    window->FirstGadget=&Gadget4;
  329.  
  330.  if (type==GAL16V8) {
  331.    RemoveGList(window,&Gadget1,4L);
  332.    gad = &Gadget20;
  333.    gadypos = 50;
  334.    for (n=0; n<8; n++) {            /*y-Koord. für Ausgänge*/
  335.      gad->TopEdge=gadypos;
  336.      gad=gad->NextGadget;
  337.      gad->TopEdge=gadypos;
  338.      gad=gad->NextGadget;
  339.      gadypos+=10; }
  340.    pins=20;
  341.    ypos=50L;
  342.    ic_hight=100L; }
  343.  else {
  344.    gad = &Gadget20;
  345.    gadypos = 40;
  346.    for (n=0; n<8; n++) {            /*y-Koord. für Ausgänge*/
  347.      gad->TopEdge=gadypos;
  348.      gad=gad->NextGadget;
  349.      gad->TopEdge=gadypos;
  350.      gad=gad->NextGadget;
  351.      gadypos+=10; }
  352.    AddGList(window,&Gadget1,-1L,-1L,NULL);    /*Gadgets für Pin1,2,14,23*/
  353.    pins=24;
  354.    ypos=30L;
  355.    ic_hight=120L; }
  356.  
  357.  RefreshGadgets(&Gadget4,window,NULL);
  358.  
  359.  Move(rp,280L,ypos-2L);                /*IC zeichnen*/
  360.  Draw(rp,360L,ypos-2L);
  361.  Draw(rp,360L,ypos+ic_hight);
  362.  Draw(rp,280L,ypos+ic_hight);
  363.  Draw(rp,280L,ypos-2L);
  364.  
  365.  Move(rp,312L,ypos-2L);                /*Markierung zeichnen*/
  366.  Draw(rp,312L,ypos+3L);
  367.  Draw(rp,326L,ypos+3L);
  368.  Draw(rp,326L,ypos-2L);
  369.  
  370.  
  371.  SetDrMd(rp,JAM1);                /*Pins zeichnen*/
  372.  for(n=1; n<=pins; n++) {
  373.    sprintf(&pinnum[0],"%2d",n);
  374.    if (n<pins/2) {
  375.      DrawLeftPin(280L,ypos);
  376.      Move(rp,264L,ypos+7L);
  377.      Text(rp,(UBYTE *)pinnum,2L);
  378.      Move(rp,285L,ypos+7L);
  379.      Text(rp,(UBYTE *)"I",1L);
  380.      ypos+=10L; }
  381.    if (n==pins/2) {
  382.      DrawLeftPin(280L,ypos);
  383.      Move(rp,264L,ypos+7L);
  384.      Text(rp,(UBYTE *)pinnum,2L); }
  385.    if (n>pins/2) {
  386.      DrawRightPin(360L,ypos);
  387.      Move(rp,361L,ypos+7L);
  388.      Text(rp,(UBYTE *)pinnum,2L);
  389.      if (n==pins/2+1) {
  390.        Move(rp,348L,ypos+7L);
  391.        Text(rp,(UBYTE *)"I",1L); }
  392.      if ((n==14)&&(GALType==GAL20V8)) {
  393.        Move(rp,348L,ypos+7L);
  394.        Text(rp,(UBYTE *)"I",1L); }
  395.      if ((n==23)&&(GALType==GAL20V8)) {
  396.        Move(rp,348L,ypos+7L);
  397.        Text(rp,(UBYTE *)"I",1L); }
  398.      ypos-=10L; }
  399.    }
  400.  SetDrMd(rp,JAM2);
  401.  
  402. }
  403.  
  404.  
  405. void DrawLeftPin(x,y)
  406. long x,y;
  407. {
  408.  Move(rp,x,y);
  409.  Draw(rp,x-18L,y);
  410.  Draw(rp,x-18L,y+8L);
  411.  Draw(rp,x,y+8L);
  412. }
  413.  
  414. void DrawRightPin(x,y)
  415. long x,y;
  416. {
  417.  Move(rp,x,y);
  418.  Draw(rp,x+18L,y);
  419.  Draw(rp,x+18L,y+8L);
  420.  Draw(rp,x,y+8L);
  421. }
  422.  
  423.  
  424.  
  425.  
  426.  
  427. /*Pinname an die Pins des GALs einstellen*/
  428. void PrintPinNames()
  429. {
  430. int    n;
  431. long    ypos;
  432.  
  433.  if (asmreadyflag) {                /*File assembliert?*/
  434.    if (gal_type == GALType) {            /*stimmt der eing. GAL-Typ?*/
  435.      ClearPinNames();
  436.      if (GALType == GAL16V8)
  437.        ypos = 50L;
  438.      else
  439.        ypos = 30L;
  440.  
  441.      for (n=1; n<=num_of_pins; n++) {
  442.        if (n < num_of_pins/2) {
  443.      Move(rp,234L-8L*(long)strlen(&PinNames[n-1][0]),ypos+7L);
  444.      ypos += 10;
  445.         }
  446.        if (n == num_of_pins/2) {
  447.      Move(rp,234L-8L*(long)strlen(&PinNames[n-1][0]),ypos+7L);
  448.         }
  449.        if (n > num_of_pins/2) {
  450.      Move(rp,406L,ypos+7L);
  451.       ypos -= 10;
  452.      }
  453.        Text(rp,&PinNames[n-1][0],(long)strlen(&PinNames[n-1][0]));
  454.       }
  455.  
  456.     }
  457.    else {
  458.      ErrorReq(9);                /*falsches GAL eingestellt*/
  459.     }
  460.   }
  461.  else {
  462.    ErrorReq(7);                    /*keine Pinnamen*/
  463.   }
  464. }
  465.  
  466.  
  467. /*Pinnamen an den Pins des GALs löschen*/
  468. void ClearPinNames()
  469. {
  470. int    n;
  471. long    ypos;
  472.  
  473.  ypos = 30L;
  474.  
  475.  for (n=1; n<=24; n++) {
  476.    if (n < 24/2) {
  477.      Move(rp,154L,ypos+7L);
  478.      ypos += 10;
  479.     }
  480.    if (n == 24/2) {
  481.      Move(rp,154L,ypos+7L);
  482.     }
  483.    if (n > 24/2) {
  484.      Move(rp,406L,ypos+7L);
  485.      ypos -= 10;
  486.     }
  487.    Text(rp,(UBYTE *)"          ",10L);
  488.   }
  489. }
  490.  
  491.